package Java.view.game.doudizhurule;


import domain.Poker;

import java.awt.*;
import java.util.ArrayList;
import java.util.List;

public class Common {

    /**
     * 根据传入的扑克牌列表判断牌型。
     *
     * @param list 扑克牌列表
     * @return 返回牌型枚举
     */
    public static PokerType judgeType(ArrayList<Poker> list) {
        int len = list.size();
        // 判断简单牌型
        if (len <= 4) {
            // 检查所有牌的值是否相同，如是，则根据牌的数量确定牌型
            if (list.size() > 0 && Common.getValue(list.get(0)) == Common.getValue(list.get(len - 1))) {
                switch (len) {
                    case 1 :
                        return PokerType.c1;
                        // 单张
                    case 2 :
                        return PokerType.c2;
                    // 对子
                    case 3 :
                        return PokerType.c3;
                     // 三张
                    case 4 :
                        return PokerType.c4;
                        // 炸弹
                }
            }

            // 特殊牌型处理，如王炸
            if (len == 2 && Common.getColor(list.get(1)) == 5)
                return PokerType.c2;
            // 复合牌型处理，如三带一
            if (len == 4 && ((Common.getValue(list.get(0)) == Common.getValue(list.get(len - 2))) ||
                    Common.getValue(list.get(1)) == Common.getValue(list.get(len - 1))))
                return PokerType.c31;
            else {
                return PokerType.c0; // 不符合任何牌型
            }
        }

        // 处理复杂牌型
        PokerIndex pokerIndex = new PokerIndex();
        ArrayList<ArrayList<Integer>> indexList = pokerIndex.indexList;
        for (int i = 0; i < 4; i++) {
            indexList.add(new ArrayList<>());
        }
        Common.getMax(pokerIndex, list);
        // 更多复杂牌型判断，如连对、飞机等
        // 复合牌型处理，如三带二
        if (list.size() == 5 &&
                ((Common.getValue(list.get(0)) == Common.getValue(list.get(len - 3))) ||
                        Common.getValue(list.get(1)) == Common.getValue(list.get(len - 2)) ||
                        Common.getValue(list.get(2)) == Common.getValue(list.get(len - 1))))
            return PokerType.c32;
        if (indexList.get(3).size() == 1 && len == 6)
            return PokerType.c411;
        if (indexList.get(3).size() == 1 && indexList.get(1).size() == 2 && len == 8)
            return PokerType.c422;
        if ((Common.getColor(list.get(0)) != 5) && (indexList.get(0).size() == len) &&
                (Common.getValue(list.get(0)) - Common.getValue(list.get(len - 1)) == len - 1))
            return PokerType.c123; // 顺子
        if (indexList.get(1).size() == len / 2 && len % 2 == 0 &&
                (Common.getValue(list.get(0)) - Common.getValue(list.get(len - 1)) == (len / 2 - 1)))
            return PokerType.c112233; // 连对
        if (indexList.get(2).size() == len / 3 && (len % 3 == 0) &&
                (Common.getValue(list.get(0)) - Common.getValue(list.get(len - 1)) == (len / 3 - 1)))
            return PokerType.c111222; // 飞机不带翼
        if (indexList.get(2).size() == len / 4 && (indexList.get(2).get(len / 4 - 1)
                - (indexList.get(2).get(0)) == len / 4 - 1))
            return PokerType.c11122234; // 飞机带单翼
        if (indexList.get(2).size() == len / 5 && indexList.get(2).size() == len / 5 &&
                ((indexList.get(2).get(len / 5 - 1)) - (indexList.get(2).get(0)) == len / 5 - 1))
            return PokerType.c1112223344; // 飞机带双翼
        return PokerType.c0;
    }

    /**
     * 移动扑克牌从一个位置到另一个位置，具有动画效果。
     *
     * @param poker 要移动的扑克牌
     * @param from  起始位置
     * @param to    目标位置
     */
    public static void move(Poker poker, Point from, Point to) {
        // 判断横向移动
        if (to.x != from.x) {
            // 计算直线斜率和截距
            double k = (double) (to.y - from.y) / (to.x - from.x);
            double b = to.y - to.x * k;
            int flag = from.x < to.x ? 20 : -20; // 设置移动方向和步长

            // 按步长移动扑克牌
            for (int i = from.x; Math.abs(i - to.x) > 20; i += flag) {
                double y = k * i + b; // 计算此位置的y坐标
                poker.setLocation(i, (int) y);
                try {
                    Thread.sleep(5); // 等待5毫秒以显示动画效果
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        poker.setLocation(to); // 设置扑克牌最终位置
    }

    /**
     * 根据扑克牌的价值对牌进行排序。
     *
     * @param list 扑克牌列表
     */
    public static void order(ArrayList<Poker> list) {
        list.sort((o1, o2) -> {
            // 解析牌的花色和数字
            int a1 = Integer.parseInt(o1.getName().substring(0, 1));
            int a2 = Integer.parseInt(o2.getName().substring(0, 1));
            int b1 = Integer.parseInt(o1.getName().substring(2));
            int b2 = Integer.parseInt(o2.getName().substring(2));

            // 大小王、A、2的特殊处理
            if (a1 == 5) b1 += 100; // 大小王的额外加分
            if (a2 == 5) b2 += 100;
            if (b1 == 1) b1 += 20; // A的额外加分
            if (b2 == 1) b2 += 20;
            if (b1 == 2) b1 += 30; // 2的额外加分
            if (b2 == 2) b2 += 30;

            // 排序逻辑：先比较牌的价值，若相同则比较花色
            int valueComparison = b2 - b1;
            return valueComparison != 0 ? valueComparison : a2 - a1;
        });
    }

    /**
     * 重新摆放扑克牌的位置。
     *
     * @param m    游戏窗体实例，用于访问和更新游戏界面。
     * @param list 扑克牌列表，包含需要重新摆放的所有扑克牌。
     * @param flag 标志位，决定扑克牌的摆放位置模式：
     *             - 如果 flag 为 0，扑克牌将摆放在界面的左侧。
     *             - 如果 flag 为 1，扑克牌将摆放在界面的底部中央。
     *             - 如果 flag 为 2，扑克牌将摆放在界面的右侧。
     */
    public static void rePosition(doudizhuJFrame m, ArrayList<Poker> list, int flag) {
        Point p = new Point();  // 创建一个点对象，用来确定每张牌的新位置

        // 根据 flag 的值设置扑克牌的新起始位置
        if (flag == 0) {
            p.x = 50;  // 设置起始 x 坐标为 50
            p.y = (450 / 2) - (list.size() + 1) * 15 / 2;  // 垂直居中，每张牌向下移动15个单位
        } else if (flag == 1) {
            p.x = (800 / 2) - (list.size() + 1) * 21 / 2;  // 水平居中，每张牌向右移动21个单位
            p.y = 450;  // 设置 y 坐标在界面底部
        } else if (flag == 2) {
            p.x = 700;  // 设置 x 坐标靠近界面的右侧
            p.y = (450 / 2) - (list.size() + 1) * 15 / 2;  // 垂直居中，每张牌向下移动15个单位
        }

        // 遍历所有扑克牌，将它们移动到新的位置
        for (Poker poker : list) {
            Common.move(poker, poker.getLocation(), p);  // 调用 move 方法移动扑克牌
            m.container.setComponentZOrder(poker, 0);  // 将扑克牌置于容器的最上层

            // 根据 flag 更新下一张牌的位置
            if (flag == 1) {
                p.x += 21;  // 水平方向排列，每张牌之间间隔21个单位
            } else {
                p.y += 15;  // 垂直方向排列，每张牌之间间隔15个单位
            }
        }
    }

    /**
     * 计算一组扑克牌的分数。
     * 特定牌有特定的分数值，例如王牌和2。
     *
     * @param list 扑克牌列表
     * @return 返回扑克牌列表的总分
     */
    public static int getScore(ArrayList<Poker> list) {
        int count = 0;  // 初始化分数计数器
        for (Poker poker : list) {
            // 检查扑克牌名称的第一个字符是否为 '5'，通常表示王牌，每张王牌算5分
            if (poker.getName().charAt(0) == '5') {
                count += 5;
            }
            // 检查扑克牌名称的第三个字符是否为 '2'，通常表示牌面为2，每张2算2分
            if (poker.getName().substring(2).equals("2")) {
                count += 2;
            }
        }
        return count;  // 返回总分
    }

    /**
     * 获取单张扑克牌的花色。
     * 扑克牌名称的第一个字符代表其花色。
     *
     * @param poker 单张扑克牌
     * @return 返回扑克牌的花色，通常是整数表示
     */
    public static int getColor(Poker poker) {
        // 解析并返回扑克牌名称的第一个字符，通常该字符为一个数字，代表花色
        return Integer.parseInt(poker.getName().substring(0, 1));
    }


    /**
     * 获取单张扑克牌的数值。
     * 牌面数值可能根据特定规则进行调整，如2和王牌的加成。
     *
     * @param poker 单张扑克牌
     * @return 返回经过调整的扑克牌数值
     */
    public static int getValue(Poker poker) {
        // 初始获取扑克牌数值，通常位于名称的第三个字符
        int i = Integer.parseInt(poker.getName().substring(2));
        // 特殊牌面值调整
        if (poker.getName().substring(2).equals("2")) {
            i += 13;  // 2的牌面值加成
        }
        if (poker.getName().substring(2).equals("1")) {
            i += 13;  // A的牌面值也视为1，并进行相同的加成
        }
        // 特殊处理王牌（花色为5），进一步加成
        if (Common.getColor(poker) == 5) {
            i += 2;  // 王牌的额外加成
        }
        return i;  // 返回调整后的牌值
    }

    /**
     * 计算一组扑克牌中每个牌面值的出现次数，并更新到PokerIndex中。
     *
     * @param pokerIndex 用于记录牌面值出现次数的数据结构。
     * @param list       扑克牌列表
     */
    public static void getMax(PokerIndex pokerIndex, ArrayList<Poker> list) {
        // 初始化计数数组，假设扑克牌值从1到13，第14位为王牌
        int[] count = new int[14];
        for (int i = 0; i < 14; i++) {
            count[i] = 0;
        }

        // 遍历所有扑克牌，统计每个牌面值的出现次数
        for (Poker poker : list) {
            if (Common.getColor(poker) == 5) {
                // 王牌计数在数组最后一位
                count[13]++;
            } else {
                // 其他牌面值计数，由于牌值从1开始，数组索引从0开始，故减1
                count[Common.getValue(poker) - 1]++;
            }
        }

        // 根据计数结果更新PokerIndex中的列表
        ArrayList<ArrayList<Integer>> indexList = pokerIndex.indexList;
        for (int i = 0; i < 14; i++) {
            switch (count[i]) {
                case 1 :indexList.get(0).add(i + 1);break;  // 出现一次的牌
                case 2 : indexList.get(1).add(i + 1); break; // 出现两次的牌
                case 3 : indexList.get(2).add(i + 1); break; // 出现三次的牌
                case 4 : indexList.get(3).add(i + 1);break;  // 出现四次的牌
            }
        }
    }


    /**
     * 根据指定的顺序应用不同的排序或组织逻辑来生成模型对象。
     *
     * @param list   扑克牌列表，包含游戏中所有的牌
     * @param orders 指定的顺序数组，定义了如何处理和排序扑克牌
     * @return 生成的Model对象，包含按照指定顺序处理过的扑克牌
     */
    public static Model getModel(ArrayList<Poker> list, int[] orders) {
        ArrayList<Poker> list2 = new ArrayList<>(list);  // 创建一个新的列表以避免修改原始列表
        Model model = new Model();  // 实例化一个新的Model对象
        // 遍历所有指定的顺序，并应用这些顺序到扑克牌列表
        for (int order : orders) {
            showOrders(order, list2, model);  // 根据指定的顺序处理并更新模型
        }
        return model;  // 返回更新后的模型
    }

    /**
     * 从扑克牌列表中获取所有顺子并添加到模型中。
     * 只有当顺子的第一张牌的值>=7且最后一张牌的值<=10且顺子长度至少为5时，才被认为是有效的顺子。
     *
     * @param list  扑克牌列表
     * @param model 存储游戏数据的模型，用于记录有效的顺子
     */
    public static void get123(ArrayList<Poker> list, Model model) {
        ArrayList<Poker> del = new ArrayList<>();  // 用于记录需要删除的牌
        // 检查列表是否非空且第一张牌的值<7或最后一张牌的值>10，如果是，则直接返回
        if (list.size() > 0 && (Common.getValue(list.get(0)) < 7 || Common.getValue(list.get(list.size() - 1)) > 10))
            return;
        // 如果列表中的牌少于5张，也直接返回
        if (list.size() < 5)
            return;

        ArrayList<Poker> list2 = new ArrayList<>(list);  // 创建新列表用于处理
        ArrayList<Poker> temp = new ArrayList<>();  // 临时列表存储唯一的牌值
        ArrayList<Integer> integers = new ArrayList<>();  // 存储已记录的牌值，避免重复
        // 过滤重复的牌值
        for (Poker poker : list2) {
            if (!integers.contains(Common.getValue(poker))) {
                integers.add(Common.getValue(poker));
                temp.add(poker);
            }
        }
        Common.order(temp);  // 对牌进行排序

        // 寻找并记录所有顺子
        for (int i = 0, len = temp.size(); i < len; i++) {
            int k = i;  // k用于标记顺子的结束位置
            // 找到连续的顺子
            for (int j = i; j < len; j++) {
                if (Common.getValue(temp.get(i)) - Common.getValue(temp.get(j)) == j - i) {
                    k = j;
                }
            }
            // 检查顺子长度是否满足条件
            if (k - i >= 4) {
                String s = "";  // 用于构建顺子字符串表示
                // 构建顺子的字符串表示，并记录到模型中
                for (int j = i; j < k; j++) {
                    s += temp.get(j).getName() + ",";
                    del.add(temp.get(j));
                }
                s += temp.get(k).getName();
                del.add(temp.get(k));
                model.a123.add(s);  // 添加顺子到模型
                i = k;  // 更新索引位置，跳过已处理的部分
            }
        }
        // 从原始列表中删除已经加入到顺子中的牌
        list.removeAll(del);
    }


    /**
     * 处理模型中存储的对子，尝试找出连对。
     *
     * @param list  扑克牌列表（未使用，可能是遗留参数）
     * @param model 存储游戏数据的模型，其中a2存储对子
     */
    public static void getTwoTwo(ArrayList<Poker> list, Model model) {
        ArrayList<String> del = new ArrayList<>(); // 用于记录需要从模型中删除的对子
        ArrayList<String> l = model.a2; // 获取模型中存储的对子列表
        if (l.size() < 3) // 如果对子数量少于3，不可能形成连对
            return;
        common(del, l, model); // 使用通用方法处理连对
        l.removeAll(del); // 从列表中移除已经处理的对子
    }

    /**
     * 处理模型中存储的三张牌组，尝试找出飞机。
     *
     * @param list  扑克牌列表（未使用，可能是遗留参数）
     * @param model 存储游戏数据的模型，其中a3存储三张牌组
     */
    public static void getPlane(ArrayList<Poker> list, Model model) {
        ArrayList<String> del = new ArrayList<>(); // 用于记录需要从模型中删除的三张牌组
        ArrayList<String> l = model.a3; // 获取模型中存储的三张牌组列表
        if (l.size() < 2) // 如果三张牌组数量少于2，不可能形成飞机
            return;
        common(del, l, model); // 使用通用方法处理飞机
        l.removeAll(del); // 从列表中移除已经处理的三张牌组
    }

    /**
     * 通用方法，用于从给定的牌组列表中识别和处理连续的牌组。
     *
     * @param del   存储需要删除的牌组
     * @param l     牌组列表
     * @param model 存储游戏数据的模型，用于记录连续牌组
     */
    public static void common(ArrayList<String> del, ArrayList<String> l, Model model) {
        Integer[] s = new Integer[l.size()]; // 存储牌组的起始值
        // 解析每个牌组的起始牌面值
        for (int i = 0, len = l.size(); i < len; i++) {
            String[] name = l.get(i).split(","); // 分割字符串以获取牌值
            s[i] = Integer.parseInt(name[0].substring(2)); // 存储每组牌的起始牌面值
        }
        // 查找并处理连续的牌组
        for (int i = 0, len = l.size(); i < len; i++) {
            int k = i; // 记录连续牌组的结束位置
            // 检查后续牌组是否形成连续序列
            for (int j = i; j < len; j++) {
                if (s[i] - s[j] == j - i)
                    k = j;
            }
            // 如果连续牌组的长度满足条件（至少三个连续元素），则记录
            if (k - i >= 2) {
                String ss = "";
                // 构建连续牌组的字符串表示，并记录到模型中
                for (int j = i; j < k; j++) {
                    ss += l.get(j) + ",";
                    del.add(l.get(j)); // 添加到删除列表
                }
                ss += l.get(k);
                model.a112233.add(ss); // 添加连续牌组到模型
                del.add(l.get(k)); // 添加最后一个元素到删除列表
                i = k; // 更新索引位置，跳过已处理的部分
            }
        }
    }

    /**
     * 从扑克牌列表中识别所有炸弹，并将它们添加到模型中。
     *
     * @param list  扑克牌列表
     * @param model 存储游戏数据的模型，其中a4用于存储炸弹
     */
    public static void getBomb(ArrayList<Poker> list, Model model) {
        ArrayList<Poker> del = new ArrayList<>(); // 用于记录需要删除的牌
        if (list.size() < 1)
            return;
        // 检查是否有王炸
        if (list.size() >= 2 && Common.getColor(list.get(0)) == 5 && Common.getColor(list.get(1)) == 5) {
            model.a4.add(list.get(0).getName() + "," + list.get(1).getName());
            del.add(list.get(0));
            del.add(list.get(1));
        }
        // 循环检查列表中是否有四张一样的牌组成的炸弹
        for (int i = 0, len = list.size(); i < len; i++) {
            if (i + 3 < len && Common.getValue(list.get(i)) == Common.getValue(list.get(i + 3))) {
                String s = list.get(i).getName() + ",";
                s += list.get(i + 1).getName() + ",";
                s += list.get(i + 2).getName() + ",";
                s += list.get(i + 3).getName();
                model.a4.add(s);
                for (int j = i; j <= i + 3; j++)
                    del.add(list.get(j));
                i = i + 3;
            }
        }
        list.removeAll(del); // 移除已识别的牌
    }

    /**
     * 从扑克牌列表中识别所有的对子，并将它们添加到模型中。
     *
     * @param list  扑克牌列表
     * @param model 存储游戏数据的模型，其中a2用于存储对子
     */
    public static void getTwo(ArrayList<Poker> list, Model model) {
        ArrayList<Poker> del = new ArrayList<>();
        for (int i = 0, len = list.size(); i < len; i++) {
            if (i + 1 < len && Common.getValue(list.get(i)) == Common.getValue(list.get(i + 1))) {
                String s = list.get(i).getName() + ",";
                s += list.get(i + 1).getName();
                model.a2.add(s);
                for (int j = i; j <= i + 1; j++)
                    del.add(list.get(j));
                i = i + 1;
            }
        }
        list.removeAll(del);
    }

    /**
     * 从扑克牌列表中识别所有的三张一样的牌，并将它们添加到模型中。
     *
     * @param list  扑克牌列表
     * @param model 存储游戏数据的模型，其中a3用于存储三张
     */
    public static void getThree(ArrayList<Poker> list, Model model) {
        ArrayList<Poker> del = new ArrayList<>();
        for (int i = 0, len = list.size(); i < len; i++) {
            if (i + 2 < len && Common.getValue(list.get(i)) == Common.getValue(list.get(i + 2))) {
                String s = list.get(i).getName() + ",";
                s += list.get(i + 1).getName() + ",";
                s += list.get(i + 2).getName();
                model.a3.add(s);
                for (int j = i; j <= i + 2; j++)
                    del.add(list.get(j));
                i = i + 2;
            }
        }
        list.removeAll(del);
    }

    /**
     * 从给定的扑克牌列表中获取单张牌并添加到模型中
     *
     * @param list  待处理的扑克牌列表
     * @param model 游戏模型对象
     */
    public static void getSingle(ArrayList<Poker> list, Model model) {
        // 创建一个新的 ArrayList 用于存储待删除的扑克牌
        ArrayList<Poker> del = new ArrayList<>();
        // 遍历 list 中的每张扑克牌
        for (Poker poker : list) {
            // 将扑克牌名称添加到模型的 a1 列表中
            model.a1.add(poker.getName());
            // 将当前扑克牌添加到 del 列表中,准备从 list 中删除
            del.add(poker);
        }
        // 从 list 中删除 del 列表中的所有扑克牌
        list.removeAll(del);
    }

    /**
     * 隐藏给定扑克牌列表中所有扑克牌
     *
     * @param list 待隐藏的扑克牌列表
     */
    public static void hideCards(ArrayList<Poker> list) {
        // 遍历 list 中的每张扑克牌
        for (Poker poker : list) {
            // 将每张扑克牌设置为不可见
            poker.setVisible(false);
        }
    }

    /**
     * 检查当前玩家出的牌是否合法
     *
     * @param c       当前玩家出的牌
     * @param current 当前回合中出过的所有牌
     * @param m       游戏界面对象
     * @return 如果当前出牌合法, 返回 1,否则返回 0
     */
    public static int checkCards(ArrayList<Poker> c, ArrayList<ArrayList<Poker>> current, doudizhuJFrame m) {
        ArrayList<Poker> currentList;
        // 如果上个玩家选择了"不要",则取出当前回合中被拒绝的牌
        if (m.time[0].getText().equals("不要"))
            currentList = current.get(2);
        else
            // 否则取出当前回合中出的最后一手牌
            currentList = current.get(0);

        // 判断当前出的牌的类型
        PokerType cType = Common.judgeType(c);
        // 判断当前回合中最后出的牌的类型
        PokerType cType2 = Common.judgeType(currentList);

        // 如果不是四张相同的牌,但出牌数量与上次不一致,则返回 0 (不合法)
        if (cType != PokerType.c4 && c.size() != currentList.size())
            return 0;
        // 如果不是四张相同的牌,但出牌类型与上次不一致,则返回 0 (不合法)
        if (cType != PokerType.c4 && Common.judgeType(c) != Common.judgeType(currentList)) {
            return 0;
        }

        // 如果出的是四张相同的牌
        if (cType == PokerType.c4) {
            // 如果出了两张,则返回 1 (合法)
            if (c.size() == 2)
                return 1;
            // 如果上次出的不是四张相同的牌,则返回 1 (合法)
            if (cType2 != PokerType.c4) {
                return 1;
            }
        }

        // 根据牌型判断出牌是否合法
        if (cType == PokerType.c1 || cType == PokerType.c2 || cType == PokerType.c3 || cType == PokerType.c4) {
            if (Common.getValue(c.get(0)) <= Common.getValue(currentList.get(0))) {
                return 0;
            } else {
                return 1;
            }
        }
        if (cType == PokerType.c123 || cType == PokerType.c112233 || cType == PokerType.c111222) {
            if (Common.getValue(c.get(0)) <= Common.getValue(currentList.get(0)))
                return 0;
            else
                return 1;
        }
        if (cType == PokerType.c31 || cType == PokerType.c32 || cType == PokerType.c411 || cType == PokerType.c422
                || cType == PokerType.c11122234 || cType == PokerType.c1112223344) {
            List<Poker> a1 = Common.getOrder2(c);
            List<Poker> a2 = Common.getOrder2(currentList);
            if (Common.getValue(a1.get(0)) < Common.getValue(a2.get(0)))
                return 0;
        }
        return 1;
    }

    /**
     * 根据牌的数量对牌进行排序,返回排序后的新牌序列
     *
     * @param list 待排序的牌
     * @return 排序后的新牌序列
     */
    public static ArrayList<Poker> getOrder2(List<Poker> list) {
        ArrayList<Poker> list2 = new ArrayList<>(list);
        ArrayList<Poker> list3 = new ArrayList<>();
        int len = list2.size();
        int[] a = new int[20];
        // 初始化计数数组a
        for (int i = 0; i < 20; i++)
            a[i] = 0;
        // 统计每种牌的数量
        for (int i = 0; i < len; i++) {
            a[Common.getValue(list2.get(i))]++;
        }

        // 按牌的数量从大到小排序
        int max = 0;
        for (int i = 0; i < 20; i++) {
            max = 0;
            for (int j = 19; j >= 0; j--) {
                if (a[j] > a[max])
                    max = j;
            }

            for (int k = 0; k < len; k++) {
                if (Common.getValue(list2.get(k)) == max) {
                    list3.add(list2.get(k));
                }
            }
            list2.remove(list3);
            a[max] = 0;
        }
        return list3;
    }

    public static void showOrders(int i, ArrayList<Poker> list, Model model) {
        // 根据输入的整型参数 i 执行不同的操作
        switch (i) {
            case 1:
                // 如果 i 为 1,调用 Common 类的 getSingle() 方法,传入 list 和 model 参数
                Common.getSingle(list, model);
                break;
            case 2:
                // 如果 i 为 2,调用 Common 类的 getTwo() 和 getTwoTwo() 方法,传入 list 和 model 参数
                Common.getTwo(list, model);
                Common.getTwoTwo(list, model);
                break;
            case 3:
                // 如果 i 为 3,调用 Common 类的 getThree() 和 getPlane() 方法,传入 list 和 model 参数
                Common.getThree(list, model);
                Common.getPlane(list, model);
                break;
            case 4:
                // 如果 i 为 4,调用 Common 类的 getBomb() 方法,传入 list 和 model 参数
                Common.getBomb(list, model);
                break;
            case 5:
                // 如果 i 为 5,调用 Common 类的 get123() 方法,传入 list 和 model 参数
                Common.get123(list, model);
                break;
        }
    }
}

